home *** CD-ROM | disk | FTP | other *** search
/ POINT Software Programming / PPROG1.ISO / pascal / swag / screen.swg / 0068_Direct VIDEO write (BASM).pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1994-08-24  |  2.5 KB  |  69 lines
  1.  
  2. procedure qwrite(x, y: byte; s: string; f, b: byte);
  3.  
  4. { Does a direct video write -- extremely fast. }
  5.  
  6. begin
  7.   asm
  8.     mov dh, y         { move X and Y into DL and DH }
  9.     mov dl, x
  10.     xor al, al
  11.     mov ah, b         { load background into AH }
  12.     mov cl, 4         { shift background over to next nibble }
  13.     shl ax, cl
  14.     add ah, f         { add foreground }
  15.     push ax           { PUSH color combo onto the stack }
  16.     mov bx, 0040h     { look at 0040h:0049h to get video mode }
  17.     mov es, bx
  18.     mov bx, 0049h
  19.     mov al, es:[bx]
  20.     cmp al, 7         { see if mode = 7 (i.e., monochrome) }
  21.     je @mono_segment
  22.     mov ax, 0b800h    { it's color: use segment B800h }
  23.     jmp @got_segment
  24.     @mono_segment:
  25.     mov ax, 0b000h    { it's mono: use segment B000h }
  26.     @got_segment:
  27.     push ax           { PUSH video segment onto stack }
  28.     mov bx, 004ah     { check 0040h:0049h to get number of screen columns }
  29.     xor ch, ch
  30.     mov cl, es:[bx]
  31.     xor ah, ah        { move Y into AL; decrement to convert Pascal coords }
  32.     mov al, dh
  33.     dec al
  34.     xor bh, bh        { shift X over into BL; decrement again }
  35.     mov bl, dl
  36.     dec bl
  37.     cmp cl, $50       { see if we're in 80-column mode }
  38.     je @eighty_column
  39.     mul cx            { multiply Y by the number of columns }
  40.     jmp @multiplied
  41.     @eighty_column:   { 80-column mode: it may be faster to perform the }
  42.     mov cl, 4         {   multiplication via shifts and adds: remember  }
  43.     shl ax, cl        {   that 80d = 1010000b , so one can SHL 4, copy  }
  44.     mov dx, ax        {   the result to DX, SHL 2, and add DX in.       }
  45.     mov cl, 2
  46.     shl ax, cl
  47.     add ax, dx
  48.     @multiplied:
  49.     add ax, bx        { add X in }
  50.     shl ax, 1         { multiply by 2 to get offset into video segment }
  51.     mov di, ax        { video pointer is in DI }
  52.     lea si, s         { string pointer is in SI }
  53.     SEGSS lodsb
  54.     cmp al, 00h       { if zero-length string, jump to end }
  55.     je @done
  56.     mov cl, al
  57.     xor ch, ch        { string length is in CX }
  58.     pop es            { get video segment back from stack; put in ES }
  59.     pop ax            { get color back from stack; put in AX (AH = color) }
  60.     @write_loop:
  61.     SEGSS lodsb       { get character to write }
  62.     mov es:[di], ax   { write AX to video memory }
  63.     inc di            { increment video pointer }
  64.     inc di
  65.     loop @write_loop  { if CX > 0, go back to top of loop }
  66.     @done:            { end }
  67.     end;
  68.   end;
  69.